// questionTypeController.js - 题目类型控制器
const mongoose = require('mongoose');
const QuestionType = require('../models/QuestionType');
const asyncHandler = require('express-async-handler');
const { isValidObjectId } = require('mongoose');

/**
 * 重构说明：
 * 1. 添加formTemplate字段支持
 * 2. 添加软删除功能支持
 * 3. 优化错误处理和数据验证
 * 4. 添加题目类型关联检查
 */


/**
 * @swagger
 * /api/question-types:
 *   post:
 *     summary: 创建新题目类型
 *     description: 创建新的题目类型
 *     tags: [QuestionTypes]
 *     requestBody:
 *       required: true
 *       content:
 *         application/json:
 *           schema:
 *             type: object
 *             required:
 *               - name
 *             properties:
 *               name:
 *                 type: string
 *                 description: 题目类型名称
 *     responses:
 *       201:
 *         description: 题目类型创建成功
 *         content:
 *           application/json:
 *             schema:
 *               $ref: '#/components/schemas/QuestionType'
 *       400:
 *         description: 参数错误
 */
const createQuestionType = asyncHandler(async (req, res) => {
  const { name, formTemplate } = req.body;

  // 验证必要字段
  if (!name || typeof name !== 'string' || name === 'string') {
    res.status(400);
    throw new Error('无效的类型名称，请使用有意义的名称');
  }

  // 检查是否已存在相同名称的记录（包括已软删除的记录）
  const existingType = await QuestionType.findOne({ 
    name, 
    deleted: false 
  });

  if (existingType) {
    // 如果存在同名但已被删除的类型，恢复它
    if (existingType.deleted) {
      existingType.deleted = false;
      existingType.formTemplate = formTemplate || { fields: [] };
      await existingType.save();
      
      res.status(200).json({
        success: true,
        data: existingType,
        reactivated: true,
        message: '已重新启用题目类型'
      });
    } else {
      res.status(409);
      throw new Error('该题目类型已存在');
    }
    return;
  }

  // 创建新类型
  const newType = await QuestionType.create({ 
    name, 
    formTemplate: formTemplate || { fields: [] } 
  });

  res.status(201).json({
    success: true,
    data: newType,
    message: '题目类型创建成功'
  });
});

/**
 * @swagger
 * /api/question-types:
 *   get:
 *     summary: 获取所有题目类型
 *     description: 获取所有启用的题目类型列表
 *     tags: [QuestionTypes]
 *     responses:
 *       200:
 *         description: 成功获取题目类型列表
 *         content:
 *           application/json:
 *             schema:
 *               type: array
 *               items:
 *                 $ref: '#/components/schemas/QuestionType'
 */
// @desc    获取所有题目类型
// @route   GET /api/question-types
// @access  公开
const getQuestionTypes = asyncHandler(async (req, res) => {
  // 查询所有题目类型并按创建时间排序
  const questionTypes = await QuestionType.find()
    .sort({ createdAt: 1 })
 // .select('name'); //用于筛选返回的属性，在这里就是只返回name
//console.log(questionTypes);

  res.status(200).json({
    success: true,
    count: questionTypes.length,
    data: questionTypes.filter(type => !type.deleted) // 过滤掉已软删除的类型
  });
});

/**
 * @swagger
 * /api/question-types/{id}:
 *   put:
 *     summary: 更新题目类型
 *     description: 更新指定的题目类型
 *     tags: [QuestionTypes]
 *     parameters:
 *       - in: path
 *         name: id
 *         required: true
 *         schema:
 *           type: string
 *         description: 题目类型ID
 *     requestBody:
 *       required: true
 *       content:
 *         application/json:
 *           schema:
 *             type: object
 *             properties:
 *               name:
 *                 type: string
 *           example:   # 移到与schema同级
 *             name: "newName"
 *     responses:
 *       '200':
 *         description: 题目类型更新成功
 *         content:
 *           application/json:
 *             schema:
 *               $ref: '#/components/schemas/QuestionType'
 *       '400':
 *         description: 参数错误
 *       '404':
 *         description: 未找到题目类型
 */

// @desc    更新题目类型
// @route   PUT /api/question-types/:id
// @access  管理员
const updateQuestionType = asyncHandler(async (req, res) => {
  const { id } = req.params;
  const { name } = req.body; // 只处理name字段

  // 验证必要参数
  if (!id || !mongoose.Types.ObjectId.isValid(id)) {
    res.status(400);
    throw new Error('无效的类型ID');
  }

  // 构建更新对象
  const updateFields = {};
  if (name) {
    // 检查新名称是否有效
    if (name === 'string') {
      res.status(400);
      throw new Error('无效的类型名称，请使用有意义的名称');
    }
    
    // 检查新名称是否已存在
    const exists = await QuestionType.findOne({ name });
    if (exists && exists._id.toString() !== id) {
      res.status(409);
      throw new Error('该题目类型名称已存在');
    }
    updateFields.name = name;
  }

  // 执行更新操作
  const updatedType = await QuestionType.findByIdAndUpdate(
    id,
    { $set: updateFields },
    { new: true, runValidators: true } // 返回更新后的文档并运行验证
  );
//).select('name createdAt'); // 选择返回的字段,上面的那一句没有.select，那就返回全部的字段

  if (!updatedType) {
    res.status(404);
    throw new Error('未找到该题目类型');
  }

  res.status(200).json({
    success: true,
    data: updatedType
  });
});

/**
 * @swagger
 * /api/question-types/{id}:
 *   delete:
 *     summary: 删除题目类型
 *     description: 软删除指定的题目类型（标记为禁用）
 *     tags: [QuestionTypes]
 *     parameters:
 *       - in: path
 *         name: id
 *         required: true
 *         schema:
 *           type: string
 *         description: 题目类型ID
 *     responses:
 *       200:
 *         description: 题目类型已禁用
 *       400:
 *         description: 参数错误
 *       404:
 *         description: 未找到题目类型
 */
// @desc    删除题目类型
// @route   DELETE /api/question-types/:id
// @access  管理员
const deleteQuestionType = asyncHandler(async (req, res) => {
  const { id } = req.params;

  // 验证ID格式
  if (!id || !mongoose.Types.ObjectId.isValid(id)) {
    return res.status(400).json({
      success: false,
      message: '无效的类型ID'
    });
  }

  // 查找要删除的类型
  const questionType = await QuestionType.findById(id);
  
  if (!questionType) {
    return res.status(404).json({
      success: false,
      message: '未找到该题目类型'
    });
  }

  // 检查是否有题目在使用该类型
  const Question = require('../models/Question');
  const questionCount = await Question.countDocuments({ type: id });
  
  if (questionCount > 0) {
    return res.status(400).json({
      success: false,
      message: `有${questionCount}道题目正在使用该类型，无法删除`
    });
  }

  // 执行软删除
  questionType.deleted = true;
  await questionType.save();

  res.status(200).json({
    success: true,
    message: '题目类型已禁用（软删除）'
  });
});

// @desc    获取单个题目类型
// @route   GET /api/question-types/:id
// @access  公开
const getQuestionTypeById = asyncHandler(async (req, res) => {
  const { id } = req.params;
  
  // 验证ID格式
  if (!id || !mongoose.Types.ObjectId.isValid(id)) {
    res.status(400);
    throw new Error('无效的题目类型ID');
  }
  
  const questionType = await QuestionType.findById(id);
  
  if (!questionType) {
    res.status(404);
    throw new Error('未找到该题目类型');
  }
  
  res.status(200).json({
    success: true,
    data: questionType
  });
});

// @desc    搜索题目类型
// @route   GET /api/question-types/search
// @access  公开
const searchQuestionTypes = asyncHandler(async (req, res) => {
  const { q } = req.query;
  
  if (!q || typeof q !== 'string') {
    res.status(400);
    throw new Error('必须提供搜索关键字');
  }

  const regex = new RegExp(q, 'i');
  const results = await QuestionType.find({
    name: regex
  }).select('name');

  res.status(200).json({
    success: true,
    count: results.length,
    data: results
  });
});

// 已移除getSubTypes和getSubTypesByType功能
// 原因：与当前模型设计不符
module.exports = {
  getQuestionTypes,
  createQuestionType,
  updateQuestionType,
  deleteQuestionType,
  getQuestionTypeById,
  searchQuestionTypes
};